const system = require('../../../utils/system.js');
import { postApi, commentApi } from '../../../utils/api';
const timeUtil = require('../../../utils/timeUtil.js');

Page({
  /**
   * 页面的初始数据
   */
  data: {
    postId: '',
    loading: true,
    post: null,
    comments: [],
    commentContent: '',
    replyPlaceholder: '写评论...',
    currentReplyId: '',
    currentReplyName: '',
    inputFocus: false,
    isLiked: false,
    sortNewest: true,
    typeMap: {
      'question': '提问',
      'share': '分享',
      'discuss': '讨论'
    },
    replyTo: null,
    statusBarHeight: 0, // 状态栏高度
    navBarHeight: 0, // 导航栏高度
    bottomSafeHeight: 0, // 底部安全高度
    imageLoading: {}, // 图片加载状态
    imageLoadErrors: {}, // 图片加载错误状态
    imageLoadSuccess: {}, // 图片加载成功状态
    isDevTools: false, // 是否在开发者工具中运行
    loadError: null, // 加载错误信息
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad(options) {
    console.log('帖子详情页面加载，参数:', options);
    
    // 获取系统信息
    const system = wx.getSystemInfoSync();
    
    this.setData({
      statusBarHeight: system.statusBarHeight,
      navBarHeight: system.navBarHeight,
      bottomSafeHeight: system.bottomSafeHeight
    });

    if (!options.id) {
      wx.showToast({
        title: '参数错误',
        icon: 'error'
      });
      setTimeout(() => {
        wx.navigateBack();
      }, 1500);
      return;
    }

    this.setData({
      postId: options.id,
      loading: true
    });
    
    // 加载帖子详情
    this.loadPostDetail();
    
    // 加载评论列表
    this.loadComments();
    
    // 检查是否在开发者工具中运行
    wx.getSystemInfo({
      success: (res) => {
        console.log('系统信息:', res);
        if (res.platform === 'devtools') {
          console.log('在开发工具中运行，启用调试功能');
          this.setData({ isDevTools: true });
          
          // 启动后自动进行图片格式测试
          setTimeout(() => {
            this.debugImageFormat();
          }, 1000);
        }
      }
    });
  },

  /**
   * 加载帖子详情
   */
  async loadPostDetail() {
    try {
      this.setData({ loading: true });
      
      // 获取帖子ID
      const postId = this.data.postId;
      if (!postId) {
        wx.showToast({
          title: '帖子不存在',
          icon: 'none'
        });
        this.goBack();
        return;
      }
      
      // 获取帖子详情
      const post = await postApi.getPostDetail(postId);
      console.log('帖子详情API返回:', post);
      
      // 确保帖子数据完整性
      if (!post) {
        this.setData({ loading: false, loadError: '帖子不存在或已删除' });
        return;
      }
      
      // 构造帖子数据，确保所有字段存在
      post.title = post.title || '';
      post.content = post.content || '';
      post.viewCount = post.viewCount || 0;
      post.commentCount = post.commentCount || 0;
      post.likeCount = post.likeCount || 0;
      
      // 构建作者信息结构，匹配模板期望的格式
      post.author = {
        name: post.nickname || post.username || '匿名用户', // 使用nickname或username
        avatar: post.userAvatar || '/images/default-avatar.png'
      };
      
      // 添加类型文本
      post.typeText = this.data.typeMap[post.type] || '讨论';
      
      // 处理图片字段
      console.log('原始图片数据:', post.images, typeof post.images);
      
      // 确保images是数组
      if (post.images) {
        try {
          // 如果images是字符串，尝试解析JSON
          if (typeof post.images === 'string') {
            try {
              // 尝试解析为JSON
              post.images = JSON.parse(post.images);
              console.log('JSON解析后的图片:', post.images);
              
              // 确保解析后的结果是数组
              if (post.images && !Array.isArray(post.images)) {
                post.images = [post.images];
                console.log('解析后的非数组结果转为数组:', post.images);
              }
            } catch (e) {
              console.error('解析帖子图片JSON失败:', e);
              // 如果解析失败，检查是否是逗号分隔的URL字符串
              if (post.images.includes(',')) {
                post.images = post.images.split(',');
                console.log('逗号分隔后的图片数组:', post.images);
              } else {
                // 单个URL的情况
                post.images = [post.images];
                console.log('单个URL转为数组:', post.images);
              }
            }
          } else if (!Array.isArray(post.images)) {
            // 如果不是数组也不是字符串，尝试转为数组
            console.log('图片数据不是数组也不是字符串，尝试转换');
            post.images = [post.images].filter(Boolean);
          }
          
          // 处理嵌套数组的情况，例如 ["/uploads/xxx.jpg"] 或 [["/uploads/xxx.jpg"]]
          if (Array.isArray(post.images) && post.images.length > 0 && Array.isArray(post.images[0])) {
            console.log('检测到嵌套数组格式的图片:', post.images);
            post.images = post.images[0];
            console.log('提取内部数组后的图片:', post.images);
          }
          
          // 确保每个图片URL都是完整的
          if (Array.isArray(post.images)) {
            post.images = post.images.filter(img => img).map(img => {
              console.log(`处理图片URL: 【${img}】 (${typeof img})`);
              
              // 处理JSON字符串格式的URL
              if (typeof img === 'string' && (img.startsWith('[') || img.startsWith('{')) && (img.endsWith(']') || img.endsWith('}'))) {
                try {
                  const parsed = JSON.parse(img);
                  if (Array.isArray(parsed) && parsed.length > 0) {
                    if (typeof parsed[0] === 'string') {
                      img = parsed[0];
                      console.log(`从JSON字符串解析出URL: ${img}`);
                    }
                  } else if (typeof parsed === 'string') {
                    img = parsed;
                    console.log(`从JSON字符串解析出URL: ${img}`);
                  }
                } catch (e) {
                  console.error('解析JSON字符串URL失败:', e);
                }
              }
              
              // 处理被引号包裹的URL
              if (typeof img === 'string' && (img.includes('"http') || img.includes('\'http'))) {
                try {
                  // 尝试提取实际URL
                  const match = img.match(/(["'])(http[^"']+)\1/);
                  if (match && match[2]) {
                    img = match[2];
                    console.log(`从引号中提取URL: ${img}`);
                  }
                } catch (e) {
                  console.error('提取引号中的URL失败:', e);
                }
              }
              
              // 如果URL不是http开头，添加域名前缀
              if (typeof img === 'string' && !img.startsWith('http')) {
                const fullUrl = `http://localhost:8080${img.startsWith('/') ? '' : '/'}${img}`;
                console.log(`添加域名前缀: ${img} -> ${fullUrl}`);
                return fullUrl;
              }
              
              // 修复API路径问题
              if (typeof img === 'string' && img.includes('/api/uploads')) {
                const fixedUrl = img.replace('/api/uploads', '/uploads');
                console.log(`修复API路径: ${img} -> ${fixedUrl}`);
                return fixedUrl;
              }
              
              return img;
            });
          } else {
            // 如果images不是数组，转为空数组
            console.log('images不是数组，设为空数组');
            post.images = [];
          }
          
          // 添加调试信息，显示每个图片URL的最终状态
          if (post.images && post.images.length > 0) {
            console.log('最终处理后的图片URLs:');
            post.images.forEach((url, index) => {
              console.log(`图片[${index}]: ${url} (${typeof url})`);
              // 测试图片可访问性
              wx.getImageInfo({
                src: url,
                success: () => console.log(`图片[${index}]可以访问`),
                fail: (err) => console.error(`图片[${index}]无法访问:`, err)
              });
            });
          }
        } catch (error) {
          console.error('处理图片数据出错:', error);
          post.images = [];
        }
        
        console.log('处理后的图片数组:', post.images);
      } else {
        post.images = [];
      }
      
      console.log('处理后的帖子图片:', post.images);
      console.log('处理后的帖子详情:', post);
      
      // 更新页面数据
      this.setData({
        post,
        isLiked: post.isLiked || false,
        loading: false
      });
    } catch (error) {
      console.error('加载帖子详情失败:', error);
      this.setData({
        loading: false,
        loadError: '加载失败，请稍后重试'
      });
    }
  },
  
  /**
   * 加载评论列表
   */
  async loadComments() {
    try {
      const result = await postApi.getCommentList(this.data.postId);
      console.log('评论列表API返回:', result);
      
      // 处理评论数据，确保是数组格式
      let comments = [];
      if (Array.isArray(result)) {
        comments = result;
      } else if (result && result.records && Array.isArray(result.records)) {
        comments = result.records;
      } else if (result && typeof result === 'object') {
        comments = [result]; // 单个评论的情况
      }
      
      // 构建评论树结构（主评论和回复）
      const mainComments = [];
      const replyMap = {};
      
      // 第一步：区分主评论和回复评论 - 先处理主评论，建立映射
      comments.forEach(comment => {
        // 添加默认值和格式化时间
        comment.content = comment.content || '';
        comment.createTime = timeUtil.formatTime(comment.createTime);
        comment.likeCount = comment.likeCount || 0;
        comment.isLiked = comment.isLiked || false;
        
        // 添加作者信息结构
        comment.author = {
          name: comment.nickname || comment.username || '未知用户', // 优先使用nickname
          avatar: comment.userAvatar || '/images/default-avatar.png'
        };
        
        // 初始化回复数组
        if (!comment.replies) {
          comment.replies = [];
        }
        
        // 优先使用parentId，如果没有则检查replyToId
        const hasParent = comment.parentId || comment.replyToId;
        
        // 只处理主评论，将其加入主评论列表和映射
        if (!hasParent) {
          mainComments.push(comment);
          replyMap[comment.id] = comment;
        }
      });
      
      // 第二步：处理回复评论，将其添加到对应的主评论下
      comments.forEach(comment => {
        // 优先使用parentId，如果没有则检查replyToId
        const parentId = comment.parentId || comment.replyToId;
        
        if (parentId) {
          // 是回复评论
          if (replyMap[parentId]) {
            // 找到了父评论或主评论
            if (comment.replyToNickname) {
              comment.replyTo = comment.replyToNickname;
            } else if (comment.replyToUsername) {
              comment.replyTo = comment.replyToUsername;
            } else if (comment.replyUserId) {
              // 通过用户ID查找用户名（后备方案）
              const replyToUser = comments.find(c => c.userId === comment.replyUserId);
              if (replyToUser) {
                comment.replyTo = replyToUser.nickname || replyToUser.username;
              }
            }
            
            // 将回复添加到父评论的回复列表中
            replyMap[parentId].replies.push(comment);
          } else {
            // 在映射中找不到父评论，作为主评论处理
            console.warn('找不到父评论，ID:', parentId, '将作为主评论处理');
            mainComments.push(comment);
            replyMap[comment.id] = comment;
          }
        }
      });
      
      // 按时间排序评论和回复
      mainComments.sort((a, b) => new Date(b.createTime) - new Date(a.createTime));
      mainComments.forEach(comment => {
        comment.replies.sort((a, b) => new Date(a.createTime) - new Date(b.createTime));
      });
      
      console.log('处理后的评论列表:', mainComments);
      
      this.setData({ comments: mainComments });
    } catch (error) {
      console.error('加载评论失败:', error);
      // 设置为空数组而不是undefined
      this.setData({ comments: [] });
    }
  },
  
  /**
   * 返回上一页
   */
  goBack() {
    wx.navigateBack({
      fail: () => {
        wx.switchTab({
          url: '/pages/forum/index'
        });
      }
    });
  },
  
  /**
   * 预览图片
   */
  previewImage(e) {
    try {
      const { url, index } = e.currentTarget.dataset;
      console.log('预览图片:', url, '索引:', index);
      
      if (!url) {
        console.error('无效的图片URL');
        wx.showToast({
          title: '图片无效',
          icon: 'none'
        });
        return;
      }
      
      // 过滤出有效的图片URL
      const validImages = Array.isArray(this.data.post.images) 
        ? this.data.post.images.filter(img => img && typeof img === 'string')
        : [];
      
      if (validImages.length === 0) {
        console.error('没有有效的图片可预览');
        wx.showToast({
          title: '无法预览图片',
          icon: 'none'
        });
        return;
      }
      
      wx.previewImage({
        current: url, // 当前显示图片的链接
        urls: validImages, // 需要预览的图片链接列表
        success: () => {
          console.log('图片预览成功');
        },
        fail: (err) => {
          console.error('预览图片失败:', err);
          wx.showToast({
            title: '预览失败',
            icon: 'none'
          });
        }
      });
    } catch (error) {
      console.error('预览图片时出错:', error);
      wx.showToast({
        title: '预览失败',
        icon: 'none'
      });
    }
  },
  
  /**
   * 点赞/取消点赞
   */
  async toggleLike() {
    if (!this.data.post) return;
    
    try {
      console.log('尝试点赞帖子ID:', this.data.postId);
      
      // 构造点赞数据参数
      const likeData = {
        targetId: this.data.postId,
        targetType: 'post' // 指定点赞目标类型为帖子
      };
      
      // 调用正确的API方法
      await postApi.toggleLike(likeData);
      
      // 更新本地状态
      const post = { ...this.data.post };
      post.liked = !post.liked;
      post.likeCount = post.liked ? post.likeCount + 1 : post.likeCount - 1;
      
      this.setData({
        isLiked: post.liked,
        post
      });
      
      // 显示操作结果
      wx.showToast({
        title: post.liked ? '点赞成功' : '已取消点赞',
        icon: 'success'
      });
    } catch (error) {
      console.error('点赞失败:', error);
      wx.showToast({
        title: '操作失败',
        icon: 'none'
      });
    }
  },
  
  /**
   * 回复评论
   */
  replyComment(e) {
    const { id, name, userid } = e.currentTarget.dataset;
    console.log('回复评论参数:', e.currentTarget.dataset);
    
    // 查找要回复的评论对象
    let targetComment = null;
    let parentComment = null;
    
    // 寻找评论和它的父评论
    for (const comment of this.data.comments) {
      if (comment.id === id) {
        targetComment = comment;
        parentComment = comment; // 如果是主评论，父评论就是它自己
        break;
      }
      
      // 检查回复列表
      for (const reply of comment.replies) {
        if (reply.id === id) {
          targetComment = reply;
          parentComment = comment; // 保存父评论引用
          break;
        }
      }
      
      if (targetComment) break;
    }
    
    if (!targetComment) {
      console.error('找不到要回复的评论:', id);
      return;
    }
    
    console.log('找到目标评论:', targetComment);
    if (parentComment) {
      console.log('父评论ID:', parentComment.id);
    }
    
    // 存储回复信息，包括清晰的父评论ID和回复目标
    this.setData({
      replyTo: {
        id: targetComment.id, // 原始评论ID
        parentId: parentComment ? parentComment.id : targetComment.id, // 如果是在回复中回复，使用主评论ID
        name: name || targetComment.author.name,
        userId: userid || targetComment.userId
      },
      replyPlaceholder: `回复 ${name || targetComment.author.name}：`,
      inputFocus: true
    });
  },
  
  /**
   * 评论输入事件
   */
  onCommentInput(e) {
    this.setData({
      commentContent: e.detail.value
    });
  },
  
  /**
   * 发布评论
   */
  async submitComment() {
    const content = this.data.commentContent.trim();
    if (!content) {
      wx.showToast({
        title: '请输入评论内容',
        icon: 'none'
      });
      return;
    }
    
    wx.showLoading({ title: '发布中...' });
    
    try {
      let success = false;
      
      // 回复其他评论
      if (this.data.replyTo) {
        success = await this.submitReply(content);
      } 
      // 新评论
      else {
        success = await this.submitNewComment(content);
      }
      
      // 清空输入内容并关闭输入框
      if (success) {
        this.setData({
          commentContent: '',
          inputFocus: false,
          replyTo: null
        });
      }
    } catch (error) {
      console.error('提交评论失败:', error);
    } finally {
      // 确保无论成功还是失败都隐藏loading
      wx.hideLoading();
    }
  },
  
  /**
   * 提交新评论
   */
  async submitNewComment(content) {
    try {
      console.log('提交评论内容:', content);
      
      // 使用正确的API函数 publishComment 替代 addComment
      await postApi.publishComment({
        postId: this.data.postId,
        content
      });

      // 重新加载评论列表
      await this.loadComments();
      
      // 更新帖子评论数
      const post = { ...this.data.post };
      post.commentCount += 1;
      
      this.setData({
        post,
        commentContent: '',
        inputFocus: false
      });
      
      wx.showToast({
        title: '评论成功',
        icon: 'success'
      });
      
      return true;
    } catch (error) {
      console.error('提交评论失败:', error);
      wx.showToast({
        title: '评论失败',
        icon: 'error'
      });
      return false;
    }
  },
  
  /**
   * 提交回复评论
   */
  async submitReply(content) {
    if (!this.data.replyTo) {
      console.error('回复目标不存在');
      return false;
    }
    
    const replyData = {
      postId: this.data.postId,
      content: content,
      parentId: this.data.replyTo.parentId || this.data.replyTo.id, // 确保使用正确的父评论ID
      replyUserId: this.data.replyTo.userId
    };
    
    console.log('提交回复评论:', replyData);
    
    try {
      wx.showLoading({ title: '发送中...' });
      
      await postApi.publishComment(replyData);
      
      // 重新加载评论列表
      await this.loadComments();
      
      // 更新帖子评论数
      if (this.data.post) {
        const post = { ...this.data.post };
        post.commentCount += 1;
        this.setData({ post });
      }
      
      wx.showToast({
        title: '回复成功',
        icon: 'success'
      });
      
      return true;
    } catch (error) {
      console.error('回复评论失败:', error);
      wx.showToast({
        title: '回复失败',
        icon: 'error'
      });
      return false;
    }
  },
  
  /**
   * 点赞评论
   */
  async likeComment(e) {
    const { id, index } = e.currentTarget.dataset;
    console.log('点赞评论:', id, index);
    
    try {
      // 构造点赞数据参数
      const likeData = {
        targetId: id,
        targetType: 'comment' // 指定点赞目标类型为评论
      };
      
      // 调用点赞API
      await postApi.toggleLike(likeData);
      
      // 更新本地状态
      const comments = [...this.data.comments];
      let targetComment = null;
      let commentIndex = -1;
      let replyIndex = -1;
      
      // 查找要点赞的评论
      for (let i = 0; i < comments.length; i++) {
        if (comments[i].id === id) {
          targetComment = comments[i];
          commentIndex = i;
          break;
        }
        
        // 检查回复列表
        for (let j = 0; j < comments[i].replies.length; j++) {
          if (comments[i].replies[j].id === id) {
            targetComment = comments[i].replies[j];
            commentIndex = i;
            replyIndex = j;
            break;
          }
        }
        
        if (targetComment) break;
      }
      
      if (targetComment) {
        // 更新点赞状态
        targetComment.isLiked = !targetComment.isLiked;
        targetComment.likeCount = targetComment.isLiked ? 
          (targetComment.likeCount + 1) : 
          Math.max(0, targetComment.likeCount - 1);
        
        // 更新数据
        this.setData({ comments });
        
        // 显示操作结果
        wx.showToast({
          title: targetComment.isLiked ? '点赞成功' : '已取消点赞',
          icon: 'success'
        });
      }
    } catch (error) {
      console.error('点赞评论失败:', error);
      wx.showToast({
        title: '操作失败',
        icon: 'none'
      });
    }
  },
  
  /**
   * 切换评论排序
   */
  toggleSortOrder() {
    const sortNewest = !this.data.sortNewest;
    let comments = [...this.data.comments];
    
    // 根据排序方式重新排序
    if (sortNewest) {
      // 按最新排序
      comments.sort((a, b) => {
        return new Date(b.createTime) - new Date(a.createTime);
      });
    } else {
      // 按最热（点赞数）排序
      comments.sort((a, b) => {
        return b.likeCount - a.likeCount;
      });
    }
    
    this.setData({
      sortNewest,
      comments
    });
    
    wx.showToast({
      title: sortNewest ? '已按最新排序' : '已按最热排序',
      icon: 'none'
    });
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage() {
    const { post, postId } = this.data;
    
    if (!post) {
      return {
        title: '学习交流平台',
        path: '/pages/forum/index'
      };
    }
    
    return {
      title: post.title,
      path: `/pages/forum/detail/index?id=${postId}`,
      imageUrl: post.images && post.images.length > 0 ? post.images[0] : ''
    };
  },

  /**
   * 处理图片加载成功
   */
  imageLoadSuccess(e) {
    const { index } = e.currentTarget.dataset;
    console.log(`图片[${index}]加载成功`);
    
    const imageLoadSuccess = { ...this.data.imageLoadSuccess };
    imageLoadSuccess[index] = true;
    
    this.setData({ imageLoadSuccess });
  },

  /**
   * 处理图片加载错误
   */
  imageLoadError(e) {
    const index = e.currentTarget.dataset.index;
    console.error(`图片加载失败，索引:${index}，URL:${this.data.post.images[index]}`);
    
    // 更新错误状态
    const imageLoadErrors = {...this.data.imageLoadErrors};
    imageLoadErrors[index] = true;
    this.setData({ imageLoadErrors });
  },

  /**
   * 重试加载图片
   */
  retryLoadImage(e) {
    const { index, url } = e.currentTarget.dataset;
    console.log(`重试加载图片[${index}]: ${url}`);
    
    // 尝试下载图片到本地缓存再显示
    wx.showLoading({
      title: '重新加载中',
      mask: true
    });
    
    // 清除错误状态
    const imageLoadErrors = {...this.data.imageLoadErrors};
    imageLoadErrors[index] = false;
    
    this.setData({ imageLoadErrors });
    
    // 尝试下载图片
    wx.downloadFile({
      url,
      success: (res) => {
        if (res.statusCode === 200) {
          console.log('下载图片到本地成功:', res.tempFilePath);
          // 更新图片路径为本地路径
          const post = {...this.data.post};
          post.images[index] = res.tempFilePath;
          
          // 更新成功状态
          const imageLoadSuccess = {...this.data.imageLoadSuccess};
          imageLoadSuccess[index] = true;
          
          this.setData({ 
            post,
            imageLoadSuccess
          });
          
          wx.hideLoading();
          wx.showToast({
            title: '加载成功',
            icon: 'success'
          });
        } else {
          this.handleImageRetryFail(index);
        }
      },
      fail: (err) => {
        console.error('重试下载图片失败:', err);
        this.handleImageRetryFail(index);
      }
    });
  },
  
  /**
   * 处理图片重试失败
   */
  handleImageRetryFail(index) {
    // 恢复错误状态
    const imageLoadErrors = {...this.data.imageLoadErrors};
    imageLoadErrors[index] = true;
    this.setData({ imageLoadErrors });
    
    wx.hideLoading();
    wx.showToast({
      title: '加载失败',
      icon: 'none'
    });
  },
  
  /**
   * 调试图片格式
   */
  debugImageFormat() {
    // 测试各种图片格式的处理
    const testFormats = [
      null,
      [],
      ["/uploads/test.jpg"],
      [["/uploads/test.jpg"]],
      "/uploads/test.jpg",
      JSON.stringify(["/uploads/test.jpg"]),
      // 添加数据库中可能存在的格式
      ["http://localhost:8080/uploads/test.jpg"],
      '"http://localhost:8080/uploads/test.jpg"',
      "\"http://localhost:8080/uploads/test.jpg\"",
      '\'http://localhost:8080/uploads/test.jpg\'',
      "[\"http://localhost:8080/uploads/test.jpg\"]",
      // 特殊测试：后端存储格式
      '["http://localhost:8080/uploads/test.jpg"]'
    ];
    
    console.log('===== 图片格式调试开始 =====');
    testFormats.forEach((format, index) => {
      try {
        console.log(`测试格式 ${index}: ${format} ${typeof format}`);
        
        // 创建临时post对象进行测试
        const testPost = {
          images: format
        };
        
        // 处理图片字段
        if (testPost.images) {
          // 如果images是字符串，尝试解析JSON
          if (typeof testPost.images === 'string') {
            try {
              // 尝试解析为JSON
              testPost.images = JSON.parse(testPost.images);
              console.log(`格式 ${index} JSON解析结果:`, testPost.images);
              
              // 确保解析后的结果是数组
              if (testPost.images && !Array.isArray(testPost.images)) {
                testPost.images = [testPost.images];
                console.log(`格式 ${index} 解析后的非数组结果转为数组:`, testPost.images);
              }
            } catch (e) {
              console.error(`格式 ${index} 不是有效的JSON:`, e.message);
              // 如果解析失败，检查是否是逗号分隔的URL字符串
              if (testPost.images.includes(',')) {
                testPost.images = testPost.images.split(',');
                console.log(`格式 ${index} 逗号分隔后:`, testPost.images);
              } else {
                // 单个URL的情况
                testPost.images = [testPost.images];
                console.log(`格式 ${index} 转为数组:`, testPost.images);
              }
            }
          } else if (!Array.isArray(testPost.images)) {
            // 如果不是数组也不是字符串，尝试转为数组
            console.log(`格式 ${index} 非数组非字符串，尝试转换`);
            testPost.images = [testPost.images].filter(Boolean);
          }
          
          // 处理嵌套数组的情况
          if (Array.isArray(testPost.images) && testPost.images.length > 0 && Array.isArray(testPost.images[0])) {
            console.log(`格式 ${index} 检测到嵌套数组:`, testPost.images);
            testPost.images = testPost.images[0];
            console.log(`格式 ${index} 提取内部数组:`, testPost.images);
          }
          
          // 确保每个图片URL都是完整的
          if (Array.isArray(testPost.images)) {
            testPost.images = testPost.images.filter(img => img).map(img => {
              console.log(`格式 ${index} 处理图片URL: 【${img}】 (${typeof img})`);
              
              // 处理JSON字符串格式的URL
              if (typeof img === 'string' && (img.startsWith('[') || img.startsWith('{')) && (img.endsWith(']') || img.endsWith('}'))) {
                try {
                  const parsed = JSON.parse(img);
                  if (Array.isArray(parsed) && parsed.length > 0) {
                    if (typeof parsed[0] === 'string') {
                      img = parsed[0];
                      console.log(`格式 ${index} 从JSON字符串解析出URL:`, img);
                    }
                  } else if (typeof parsed === 'string') {
                    img = parsed;
                    console.log(`格式 ${index} 从JSON字符串解析出URL:`, img);
                  }
                } catch (e) {
                  console.error(`格式 ${index} 解析JSON字符串URL失败:`, e);
                }
              }
              
              // 处理被引号包裹的URL
              if (typeof img === 'string' && (img.includes('"http') || img.includes('\'http'))) {
                try {
                  // 尝试提取实际URL
                  const match = img.match(/(["'])(http[^"']+)\1/);
                  if (match && match[2]) {
                    img = match[2];
                    console.log(`格式 ${index} 从引号中提取URL:`, img);
                  }
                } catch (e) {
                  console.error(`格式 ${index} 提取引号中的URL失败:`, e);
                }
              }
              
              // 如果URL不是http开头，添加域名前缀
              if (typeof img === 'string' && !img.startsWith('http')) {
                const fullUrl = `http://localhost:8080${img.startsWith('/') ? '' : '/'}${img}`;
                console.log(`格式 ${index} 添加域名前缀: ${img} -> ${fullUrl}`);
                return fullUrl;
              }
              
              // 修复API路径问题
              if (typeof img === 'string' && img.includes('/api/uploads')) {
                const fixedUrl = img.replace('/api/uploads', '/uploads');
                console.log(`格式 ${index} 修复API路径: ${img} -> ${fixedUrl}`);
                return fixedUrl;
              }
              
              return img;
            });
          } else {
            // 如果images不是数组，转为空数组
            console.log(`格式 ${index} images不是数组，设为空数组`);
            testPost.images = [];
          }
          
          console.log(`格式 ${index} 最终处理结果:`, testPost.images);
        } else {
          console.log(`格式 ${index} 处理结果 (null/undefined):`, []);
          testPost.images = [];
        }
      } catch (error) {
        console.error(`格式 ${index} 处理出错:`, error);
      }
    });
    console.log('===== 图片格式调试结束 =====');
  },

  /**
   * 手动测试特定格式的图片数据
   * 在控制台调用：Page.testImageFormat('["http://localhost:8080/uploads/test.jpg"]')
   */
  testImageFormat(format) {
    console.log('===== 手动测试图片格式开始 =====');
    console.log('测试格式:', format, typeof format);
    
    try {
      // 创建临时post对象
      const post = { ...this.data.post };
      const originalImages = post.images ? [...post.images] : [];
      
      // 设置测试数据
      post.images = format;
      
      // 处理图片字段
      if (post.images) {
        // 如果images是字符串，尝试解析JSON
        if (typeof post.images === 'string') {
          try {
            // 尝试解析为JSON
            post.images = JSON.parse(post.images);
            console.log('JSON解析后的图片:', post.images);
            
            // 确保解析后的结果是数组
            if (post.images && !Array.isArray(post.images)) {
              post.images = [post.images];
              console.log('解析后的非数组结果转为数组:', post.images);
            }
          } catch (e) {
            console.error('解析帖子图片JSON失败:', e);
            // 如果解析失败，检查是否是逗号分隔的URL字符串
            if (post.images.includes(',')) {
              post.images = post.images.split(',');
              console.log('逗号分隔后的图片数组:', post.images);
            } else {
              // 单个URL的情况
              post.images = [post.images];
              console.log('单个URL转为数组:', post.images);
            }
          }
        } else if (!Array.isArray(post.images)) {
          // 如果不是数组也不是字符串，尝试转为数组
          console.log('图片数据不是数组也不是字符串，尝试转换');
          post.images = [post.images].filter(Boolean);
        }
        
        // 处理嵌套数组的情况
        if (Array.isArray(post.images) && post.images.length > 0 && Array.isArray(post.images[0])) {
          console.log('检测到嵌套数组格式的图片:', post.images);
          post.images = post.images[0];
          console.log('提取内部数组后的图片:', post.images);
        }
        
        // 确保每个图片URL都是完整的
        if (Array.isArray(post.images)) {
          post.images = post.images.filter(img => img).map(img => {
            console.log(`处理图片URL: 【${img}】 (${typeof img})`);
            
            // 处理JSON字符串格式的URL
            if (typeof img === 'string' && (img.startsWith('[') || img.startsWith('{')) && (img.endsWith(']') || img.endsWith('}'))) {
              try {
                const parsed = JSON.parse(img);
                if (Array.isArray(parsed) && parsed.length > 0) {
                  if (typeof parsed[0] === 'string') {
                    img = parsed[0];
                    console.log(`从JSON字符串解析出URL: ${img}`);
                  }
                } else if (typeof parsed === 'string') {
                  img = parsed;
                  console.log(`从JSON字符串解析出URL: ${img}`);
                }
              } catch (e) {
                console.error('解析JSON字符串URL失败:', e);
              }
            }
            
            // 处理被引号包裹的URL
            if (typeof img === 'string' && (img.includes('"http') || img.includes('\'http'))) {
              try {
                // 尝试提取实际URL
                const match = img.match(/(["'])(http[^"']+)\1/);
                if (match && match[2]) {
                  img = match[2];
                  console.log(`从引号中提取URL: ${img}`);
                }
              } catch (e) {
                console.error('提取引号中的URL失败:', e);
              }
            }
            
            // 如果URL不是http开头，添加域名前缀
            if (typeof img === 'string' && !img.startsWith('http')) {
              const fullUrl = `http://localhost:8080${img.startsWith('/') ? '' : '/'}${img}`;
              console.log(`添加域名前缀: ${img} -> ${fullUrl}`);
              return fullUrl;
            }
            
            // 修复API路径问题
            if (typeof img === 'string' && img.includes('/api/uploads')) {
              const fixedUrl = img.replace('/api/uploads', '/uploads');
              console.log(`修复API路径: ${img} -> ${fixedUrl}`);
              return fixedUrl;
            }
            
            return img;
          });
        } else {
          // 如果images不是数组，转为空数组
          console.log('images不是数组，设为空数组');
          post.images = [];
        }
        
        console.log('处理后的图片数组:', post.images);
        
        // 临时应用处理后的图片进行测试
        if (post.images && post.images.length > 0) {
          // 临时更新数据，显示处理后的图片
          this.setData({ post });
          
          // 显示测试成功提示
          wx.showToast({
            title: '测试图片已应用',
            icon: 'success'
          });
          
          // 3秒后恢复原始数据
          setTimeout(() => {
            post.images = originalImages;
            this.setData({ post });
            console.log('已恢复原始图片数据');
          }, 3000);
        } else {
          console.log('处理后没有有效图片，不应用测试');
          wx.showToast({
            title: '无有效图片',
            icon: 'none'
          });
        }
      }
    } catch (error) {
      console.error('测试图片格式出错:', error);
    }
    
    console.log('===== 手动测试图片格式结束 =====');
  },
}) 